Структурные элементы класса, методы взаимодействия объектов и организация наследования

Содержание лекции

• Компонентные характеристики в определении класса
• Доступ к переменным и методам
• Конструкторы и создание объектов класса
• Время жизни объекта
• Перегрузка и переопределение методов
• Наследование классов
• Создание многоуровневой иерархии
• Динамическая диспетчеризация методов
• Абстрактные классы

Компонентные характеристики класса

class NetworkDevice {
private:                    // Закрытые члены
    string macAddress;      // Поле данных
    string ipAddress;       // Поле данных
    bool isConnected;       // Поле данных
    
protected:                  // Защищённые члены
    int signalStrength;     // Доступны наследникам
    
public:                     // Открытые члены
    // Конструкторы
    NetworkDevice();        // Конструктор по умолчанию
    NetworkDevice(const string& mac);  // Параметризованный конструктор
    
    // Методы
    void connect();         // Метод без параметров
    void disconnect();      // Метод без параметров
    bool checkStatus() const;  // Константный метод
};

Спецификаторы доступа

class ServerConnection {
private:
    // Доступны только внутри класса
    string password;
    void encryptData(string& data);
    
protected:
    // Доступны внутри класса и наследникам
    string serverAddress;
    int port;
    void logConnection();
    
public:
    // Доступны из любого места программы
    void connect(const string& addr, int p);
    void sendData(const string& data);
    void disconnect();
};

Доступ к переменным и методам

class NetworkPacket {
private:
    int packetId;
    string data;
    time_t timestamp;
    
public:
    // Прямой доступ к данным (не рекомендуется)
    int getPacketId() { return packetId; }
    
    // Контролируемый доступ через методы
    void setData(const string& newData) {
        if (newData.length() > 0 && newData.length() < 1500) {
            data = newData;
            timestamp = time(nullptr);
        }
    }
    
    string getData() const { return data; }
    
    // Проверка данных перед доступом
    bool isValid() const {
        return !data.empty() && packetId > 0;
    }
};

Инкапсуляция данных

class SecureConnection {
private:
    string encryptionKey;
    bool connectionEstablished;
    
    // Приватные вспомогательные методы
    string generateKey() {
        return "key_" + to_string(time(nullptr));
    }
    
    bool validateCertificate() {
        // Проверка сертификата
        return true;
    }
    
public:
    void establishConnection() {
        encryptionKey = generateKey();
        connectionEstablished = validateCertificate();
    }
    
    void sendSecureMessage(const string& message) {
        if (connectionEstablished) {
            string encrypted = encrypt(message, encryptionKey);
            // Отправка зашифрованного сообщения
        }
    }
};

Конструкторы класса

class NetworkClient {
private:
    string serverIp;
    int port;
    bool autoReconnect;
    
public:
    // Конструктор по умолчанию
    NetworkClient() : serverIp("127.0.0.1"), port(8080), autoReconnect(true) {}
    
    // Параметризованный конструктор
    NetworkClient(const string& ip, int p) : serverIp(ip), port(p), autoReconnect(true) {}
    
    // Конструктор с параметрами по умолчанию
    NetworkClient(const string& ip, int p = 80, bool reconnect = false) 
        : serverIp(ip), port(p), autoReconnect(reconnect) {}
    
    // Конструктор копирования
    NetworkClient(const NetworkClient& other) 
        : serverIp(other.serverIp), port(other.port), autoReconnect(other.autoReconnect) {}
};

Списки инициализации

class ServerConfig {
private:
    const int maxConnections;
    const int bufferSize;
    string serverName;
    vector<string> allowedIPs;
    
public:
    // Инициализация в списке инициализации
    ServerConfig(const string& name, int maxConn) 
        : maxConnections(maxConn), 
          bufferSize(4096),
          serverName(name),
          allowedIPs({"127.0.0.1", "192.168.1.1"}) {
        // Тело конструктора
        cout << "Server " << serverName << " configured" << endl;
    }
};

Деструктор класса

class NetworkResource {
private:
    int* buffer;
    int socketDescriptor;
    bool resourcesAllocated;
    
public:
    NetworkResource(int size) {
        buffer = new int[size];
        socketDescriptor = socket(AF_INET, SOCK_STREAM, 0);
        resourcesAllocated = true;
        cout << "Resources allocated" << endl;
    }
    
    // Деструктор
    ~NetworkResource() {
        if (resourcesAllocated) {
            delete[] buffer;           // Освобождение памяти
            close(socketDescriptor);   // Закрытие сокета
            resourcesAllocated = false;
            cout << "Resources freed" << endl;
        }
    }
};

Создание объектов класса

class NetworkService {
private:
    string serviceName;
    int port;
    
public:
    NetworkService(const string& name, int p) : serviceName(name), port(p) {}
    void start() { cout << "Service " << serviceName << " started on port " << port << endl; }
};

int main() {
    // Создание объекта на стеке
    NetworkService httpService("HTTP", 80);
    httpService.start();
    
    // Создание объекта в куче
    NetworkService* ftpService = new NetworkService("FTP", 21);
    ftpService->start();
    
    // Создание массива объектов
    NetworkService services[] = {
        NetworkService("SSH", 22),
        NetworkService("SMTP", 25),
        NetworkService("DNS", 53)
    };
    
    // Создание вектора объектов
    vector<NetworkService> serviceList = {
        NetworkService("HTTP", 80),
        NetworkService("HTTPS", 443)
    };
    
    delete ftpService; // Освобождение памяти
    return 0;
}

Время жизни объекта

class ConnectionManager {
private:
    static int activeConnections;
    int connectionId;
    
public:
    ConnectionManager() {
        connectionId = ++activeConnections;
        cout << "Connection " << connectionId << " created" << endl;
    }
    
    ~ConnectionManager() {
        activeConnections--;
        cout << "Connection " << connectionId << " destroyed" << endl;
    }
    
    static int getActiveConnections() { return activeConnections; }
};

int ConnectionManager::activeConnections = 0;

void createTemporaryConnection() {
    ConnectionManager temp;  // Создание временного объекта
    cout << "Active connections: " << ConnectionManager::getActiveConnections() << endl;
} // temp автоматически уничтожается здесь

Перегрузка методов

class DataProcessor {
public:
    // Перегрузка по количеству параметров
    void processData(const string& data) {
        cout << "Processing single data: " << data << endl;
    }
    
    void processData(const string& data1, const string& data2) {
        cout << "Processing pair: " << data1 << " and " << data2 << endl;
    }
    
    // Перегрузка по типам параметров
    void processData(int number) {
        cout << "Processing number: " << number << endl;
    }
    
    void processData(double value) {
        cout << "Processing double: " << value << endl;
    }
    
    // Перегрузка с различными модификаторами const
    void processData() { cout << "Non-const version" << endl; }
    void processData() const { cout << "Const version" << endl; }
};

Перегрузка операторов

class NetworkAddress {
private:
    string ip;
    int port;
    
public:
    NetworkAddress(const string& ipAddr, int p) : ip(ipAddr), port(p) {}
    
    // Перегрузка оператора сравнения
    bool operator==(const NetworkAddress& other) const {
        return ip == other.ip && port == other.port;
    }
    
    // Перегрузка оператора присваивания
    NetworkAddress& operator=(const NetworkAddress& other) {
        if (this != &other) {
            ip = other.ip;
            port = other.port;
        }
        return *this;
    }
    
    // Перегрузка оператора вывода
    friend ostream& operator<<(ostream& os, const NetworkAddress& addr) {
        os << addr.ip << ":" << addr.port;
        return os;
    }
};

Переопределение методов

class NetworkProtocol {
public:
    virtual void sendData(const string& data) {
        cout << "Basic protocol sending: " << data << endl;
    }
    
    virtual string receiveData() {
        return "Basic data received";
    }
    
    virtual ~NetworkProtocol() = default;
};

class TCPProtocol : public NetworkProtocol {
public:
    void sendData(const string& data) override {
        cout << "TCP protocol establishing connection..." << endl;
        cout << "TCP sending reliable data: " << data << endl;
    }
    
    string receiveData() override {
        return "TCP received: reliable data stream";
    }
};

class UDPProtocol : public NetworkProtocol {
public:
    void sendData(const string& data) override {
        cout << "UDP protocol sending datagram: " << data << endl;
    }
    
    string receiveData() override {
        return "UDP received: datagram packet";
    }
};

Виртуальные методы

class Connection {
protected:
    string connectionType;
    
public:
    Connection() : connectionType("Basic") {}
    
    // Виртуальный метод
    virtual void establish() {
        cout << "Establishing " << connectionType << " connection" << endl;
    }
    
    // Чисто виртуальный метод
    virtual void transmit(const string& data) = 0;
    
    virtual ~Connection() = default;
};

class SecureConnection : public Connection {
public:
    SecureConnection() { connectionType = "Secure"; }
    
    void establish() override {
        cout << "Establishing secure connection with encryption" << endl;
    }
    
    void transmit(const string& data) override {
        cout << "Transmitting encrypted data: " << data << endl;
    }
};

Наследование классов

class Device {
protected:
    string deviceId;
    string manufacturer;
    bool isActive;
    
public:
    Device(const string& id, const string& maker) 
        : deviceId(id), manufacturer(maker), isActive(false) {}
    
    void activate() { isActive = true; }
    void deactivate() { isActive = false; }
    bool getStatus() const { return isActive; }
};

class NetworkDevice : public Device {
protected:
    string ipAddress;
    string macAddress;
    
public:
    NetworkDevice(const string& id, const string& maker, const string& ip) 
        : Device(id, maker), ipAddress(ip) {}
    
    void setMacAddress(const string& mac) { macAddress = mac; }
    string getIpAddress() const { return ipAddress; }
};

class Router : public NetworkDevice {
private:
    int portCount;
    vector<string> routingTable;
    
public:
    Router(const string& id, const string& maker, const string& ip, int ports) 
        : NetworkDevice(id, maker, ip), portCount(ports) {}
    
    void addRoute(const string& destination) {
        routingTable.push_back(destination);
    }
};

Типы наследования

class BaseNetworkService {
public:
    void publicMethod() { cout << "Public method" << endl; }
protected:
    void protectedMethod() { cout << "Protected method" << endl; }
private:
    void privateMethod() { cout << "Private method" << endl; }
};

// Публичное наследование
class PublicService : public BaseNetworkService {
    // publicMethod остается public
    // protectedMethod остается protected
    // privateMethod недоступен
};

// Защищенное наследование
class ProtectedService : protected BaseNetworkService {
    // publicMethod становится protected
    // protectedMethod остается protected
    // privateMethod недоступен
};

// Приватное наследование
class PrivateService : private BaseNetworkService {
    // publicMethod становится private
    // protectedMethod становится private
    // privateMethod недоступен
};

Множественное наследование

class ConnectionInterface {
public:
    virtual void connect() = 0;
    virtual void disconnect() = 0;
    virtual ~ConnectionInterface() = default;
};

class DataProcessor {
public:
    virtual void processData(const string& data) = 0;
    virtual ~DataProcessor() = default;
};

class EncryptionProvider {
public:
    virtual string encrypt(const string& data) = 0;
    virtual string decrypt(const string& data) = 0;
    virtual ~EncryptionProvider() = default;
};

// Класс, реализующий несколько интерфейсов
class SecureNetworkConnection : public ConnectionInterface, 
                               public DataProcessor, 
                               public EncryptionProvider {
private:
    bool isConnected;
    
public:
    void connect() override { isConnected = true; }
    void disconnect() override { isConnected = false; }
    void processData(const string& data) override {
        if (isConnected) {
            string encrypted = encrypt(data);
            cout << "Processing encrypted: " << encrypted << endl;
        }
    }
    string encrypt(const string& data) override {
        return "encrypted_" + data;
    }
    string decrypt(const string& data) override {
        return data.substr(10); // Убираем "encrypted_"
    }
};

Проблема ромбовидного наследования

class NetworkComponent {
protected:
    string componentId;
    
public:
    NetworkComponent(const string& id) : componentId(id) {}
    virtual void initialize() = 0;
};

// Виртуальное наследование
class Sender : virtual public NetworkComponent {
public:
    Sender(const string& id) : NetworkComponent(id) {}
    virtual void send(const string& data) = 0;
};

// Виртуальное наследование
class Receiver : virtual public NetworkComponent {
public:
    Receiver(const string& id) : NetworkComponent(id) {}
    virtual string receive() = 0;
};

// Отсутствует неоднозначность благодаря виртуальному наследованию
class Transceiver : public Sender, public Receiver {
public:
    Transceiver(const string& id) : NetworkComponent(id), Sender(id), Receiver(id) {}
    
    void initialize() override {
        cout << "Transceiver " << componentId << " initialized" << endl;
    }
    
    void send(const string& data) override {
        cout << "Sending: " << data << endl;
    }
    
    string receive() override {
        return "Received data";
    }
};

Сокрытие методов

class BaseServer {
public:
    void start() { cout << "Base server started" << endl; }
    void stop() { cout << "Base server stopped" << endl; }
    
    // Виртуальный метод для переопределения
    virtual void handleRequest(const string& request) {
        cout << "Base handling: " << request << endl;
    }
};

class WebServer : public BaseServer {
public:
    // Сокрытие (hiding) метода start() базового класса
    void start() { 
        cout << "Web server started on port 80" << endl; 
    }
    
    // Переопределение виртуального метода
    void handleRequest(const string& request) override {
        cout << "Web server processing HTTP request: " << request << endl;
    }
    
    // Добавление нового метода
    void configureVirtualHosts() {
        cout << "Virtual hosts configured" << endl;
    }
};

Динамическая диспетчеризация

class NetworkHandler {
public:
    virtual void processPacket(const string& packet) {
        cout << "Basic packet processing" << endl;
    }
    
    virtual ~NetworkHandler() = default;
};

class TCPHandler : public NetworkHandler {
public:
    void processPacket(const string& packet) override {
        cout << "TCP packet processing: reliable delivery" << endl;
    }
};

class UDPHandler : public NetworkHandler {
public:
    void processPacket(const string& packet) override {
        cout << "UDP packet processing: best effort delivery" << endl;
    }
};

// Функция, использующая полиморфизм
void handleNetworkTraffic(NetworkHandler* handler, const string& packet) {
    // Динамическая диспетчеризация - выбор метода во время выполнения
    handler->processPacket(packet);
}

int main() {
    NetworkHandler* handlers[] = {
        new TCPHandler(),
        new UDPHandler(),
        new NetworkHandler()
    };
    
    for (auto handler : handlers) {
        handleNetworkTraffic(handler, "test packet");
        delete handler;
    }
    
    return 0;
}

Абстрактные классы

class Protocol {
protected:
    string protocolName;
    int defaultPort;
    
public:
    Protocol(const string& name, int port) : protocolName(name), defaultPort(port) {}
    
    // Чисто виртуальные методы
    virtual void establishConnection(const string& address, int port) = 0;
    virtual void sendData(const string& data) = 0;
    virtual string receiveData() = 0;
    virtual void closeConnection() = 0;
    
    // Виртуальный деструктор
    virtual ~Protocol() = default;
    
    // Обычный метод
    string getProtocolName() const { return protocolName; }
};

// Конкретная реализация
class HTTPProtocol : public Protocol {
public:
    HTTPProtocol() : Protocol("HTTP", 80) {}
    
    void establishConnection(const string& address, int port) override {
        cout << "Establishing HTTP connection to " << address << ":" << port << endl;
    }
    
    void sendData(const string& data) override {
        cout << "Sending HTTP request: " << data << endl;
    }
    
    string receiveData() override {
        return "HTTP/1.1 200 OK\nContent-Type: text/html\n\n<html>...</html>";
    }
    
    void closeConnection() override {
        cout << "Closing HTTP connection" << endl;
    }
};

Интерфейсы в C++

// Интерфейс для шифрования
class IEncryption {
public:
    virtual string encrypt(const string& plaintext) = 0;
    virtual string decrypt(const string& ciphertext) = 0;
    virtual ~IEncryption() = default;
};

// Интерфейс для аутентификации
class IAuthentication {
public:
    virtual bool authenticate(const string& username, const string& password) = 0;
    virtual void logout() = 0;
    virtual ~IAuthentication() = default;
};

// Интерфейс для логирования
class ILogger {
public:
    virtual void log(const string& message) = 0;
    virtual void setLogLevel(int level) = 0;
    virtual ~ILogger() = default;
};

// Класс, реализующий несколько интерфейсов
class SecureNetworkService : public IEncryption, public IAuthentication, public ILogger {
private:
    int logLevel;
    
public:
    string encrypt(const string& plaintext) override {
        return "encrypted_" + plaintext;
    }
    
    string decrypt(const string& ciphertext) override {
        return ciphertext.substr(10); // Убираем "encrypted_"
    }
    
    bool authenticate(const string& username, const string& password) override {
        return username == "admin" && password == "secret";
    }
    
    void logout() override {
        log("User logged out");
    }
    
    void log(const string& message) override {
        if (logLevel > 0) {
            cout << "[LOG] " << message << endl;
        }
    }
    
    void setLogLevel(int level) override {
        logLevel = level;
    }
};

Шаблонные классы

template <typename T>
class NetworkBuffer {
private:
    vector<T> buffer;
    size_t maxSize;
    
public:
    NetworkBuffer(size_t size) : maxSize(size) {}
    
    bool add(const T& item) {
        if (buffer.size() < maxSize) {
            buffer.push_back(item);
            return true;
        }
        return false;
    }
    
    T get() {
        if (!buffer.empty()) {
            T item = buffer.front();
            buffer.erase(buffer.begin());
            return item;
        }
        return T(); // Возвращаем значение по умолчанию
    }
    
    size_t size() const { return buffer.size(); }
    bool empty() const { return buffer.empty(); }
};

// Использование шаблонного класса
int main() {
    NetworkBuffer<string> stringBuffer(10);
    stringBuffer.add("Hello");
    stringBuffer.add("World");
    
    NetworkBuffer<int> intBuffer(5);
    intBuffer.add(42);
    intBuffer.add(100);
    
    return 0;
}

Заключение

Основные концепции:

• Инкапсуляция - сокрытие данных и реализации
• Наследование - повторное использование кода и создание иерархий
• Полиморфизм - единый интерфейс для разных реализаций
• Абстракция - выделение общих характеристик

Рекомендации:

1. Используйте спецификаторы доступа для защиты данных
2. Предпочитайте композицию наследованию, когда это возможно
3. Используйте виртуальные методы для полиморфного поведения
4. Создавайте абстрактные классы для определения интерфейсов
5. Помните о виртуальном наследовании при множественном наследовании
6. Правильно управляйте временем жизни объектов

Вопросы для самопроверки

1. Чем отличаются спецификаторы доступа private, protected и public?
2. Какие типы конструкторов существуют в C++?
3. Что такое виртуальные методы и зачем они нужны?
4. В чем различие между перегрузкой и переопределением методов?
5. Как решается проблема ромбовидного наследования?
6. Что такое чисто виртуальные методы и абстрактные классы?
7. Когда использовать множественное наследование?
8. Как работает динамическая диспетчеризация методов?